Java实现一致性哈希算法，并搭建环境测试其负载均衡特性

大家好，我是本周的值班编辑 江南一点雨 ，本周将由我为大家排版并送出技术干货，大家可以在公众号后台回复“java”，获得作者 Java 知识体系/面试必看资料。

---

实现负载均衡是后端领域一个重要的话题，一致性哈希算法是实现服务器负载均衡的方法之一，你很可能已在一些远程服务框架中使用过它。下面我们尝试一下自己实现一致性哈希算法。

一. 简述一致性哈希算法

这里不详细介绍一致性哈希算法的起源了，网上能方便地搜到许多介绍一致性哈希算法的好文章。本文主要想动手实现一致性哈希算法，并搭建一个环境进行实战测试。

在开始之前先整理一下算法的思路:

一致性哈希算法通过把每台服务器的哈希值打在哈希环上，把哈希环分成不同的段，然后对到来的请求计算哈希值从而得知该请求所归属的服务器。这个办法解决了传统服务器增减机器时需要重新计算哈希的麻烦。

但如果服务器的数量较少，可能导致计算出的哈希值相差较小，在哈希环上分布不均匀，导致某台服务器过载。为了解决负载均衡问题，我们引入虚拟节点技术，为每台服务器分配一定数量的节点，通过节点的哈希值在哈希环上进行划分。这样一来，我们就可以根据机器的性能为其分配节点，性能好就多分配一点，差就少一点，从而达到负载均衡。

二. 实现一致性哈希算法

奠定了整体思路后我们开始考虑实现的细节

1. 哈希算法的选择

选择能散列出32位整数的 FNV 算法, 由于该哈希函数可能产生负数, 需要作取绝对值处理.

1. 请求节点在哈希环上寻找对应服务器的策略

策略为：新节点寻找最近比且它大的节点, 比如说现在已经有环[0, 5, 7, 10], 来了个哈希值为6的节点, 那么它应该由哈希值为7对应的服务器处理. 如果请求节点所计算的哈希值大于环上的所有节点, 那么就取第一个节点. 比如来了个11, 将分配到0所对应的节点.

1. 哈希环的组织结构

开始的时候想过用顺序存储的结构存放，但是在一致性哈希中，最频繁的操作是在集合中查找最近且比目标大的数. 如果用顺序存储结构的话，时间复杂度是收敛于O(N)的，而树形结构则为更优的O(logN)。

但凡事有两面，采用树形结构存储的代价是数据初始化的效率较低，而且运行期间如果有节点插入删除的话效率也比较低。但是在现实中，服务器在一开始注册后基本上就不怎么变了，期间增减机器，宕机，机器修复等事件的频率相比起节点的查询简直是微不足道。所以本案例决定使用使用树形结构存储。

贴合上述要求，并且提供有序存储的，首先想到的是红黑树，而且Java中提供了红黑树的实现 TreeMap。

1. 虚拟节点与真实节点的映射关系

如何确定一个虚拟节点对应的真实节点也是个问题。理论上应该维护一张表记录真实节点与虚拟节点的映射关系。本案例为了演示，采用简单的字符串处理。

比方说服务器 192.168.0.1:8888分配了 1000 个虚拟节点, 那么它的虚拟节点名称从 192.168.0.1:8888@1一直到 192.168.0.1:8888@1000。通过这样的处理，我们在通过虚拟节点找真实节点时只需要裁剪字符串即可。

计划定制好后, 下面是具体代码：

1. public class ConsistentHashTest {

2. /**

3. * 服务器列表,一共有3台服务器提供服务, 将根据性能分配虚拟节点

4. */

5. public static String[] servers = {

6. "192.168.0.1#100", //服务器1: 性能指数100, 将获得1000个虚拟节点

7. "192.168.0.2#100", //服务器2: 性能指数100, 将获得1000个虚拟节点

8. "192.168.0.3#30" //服务器3: 性能指数30, 将获得300个虚拟节点

9. };

10. /**

11. * 真实服务器列表, 由于增加与删除的频率比遍历高, 用链表存储比较划算

12. */

13. private static List<String> realNodes = new LinkedList<>();

14. /**

15. * 虚拟节点列表

16. */

17. private static TreeMap<Integer, String> virtualNodes = new TreeMap<>();

18. static{

19. for(String s : servers){

20. //把服务器加入真实服务器列表中

21. realNodes.add(s);

22. String[] strs = s.split("#");

23. //服务器名称, 省略端口号

24. String name = strs[0];

25. //根据服务器性能给每台真实服务器分配虚拟节点, 并把虚拟节点放到虚拟节点列表中.

26. int virtualNodeNum = Integer.parseInt(strs[1]) * 10;

27. for(int i = 1; i <= virtualNodeNum; i++){

28. virtualNodes.put(FVNHash(name + "@" + i), name + "@" + i);

29. }

30. }

31. }

32. public static void main(String[] args) {

33. new Thread(new RequestProcess()).start();

34. }

35. static class RequestProcess implements Runnable{

36. @Override

37. public void run() {

38. String client = null;

39. while(true){

40. //模拟产生一个请求

41. client = getN() + "." + getN() + "." + getN() + "." + getN() + ":" + (1000 + (int)(Math.random() * 9000));

42. //计算请求的哈希值

43. int hash = FVNHash(client);

44. //判断请求将由哪台服务器处理

45. System.out.println(client + " 的请求将由 " + getServer(client) + " 处理");

46. try {

47. Thread.sleep(500);

48. } catch (InterruptedException e) {

49. e.printStackTrace();

50. }

51. }

52. }

53. }

54. private static String getServer(String client) {

55. //计算客户端请求的哈希值

56. int hash = FVNHash(client);

57. //得到大于该哈希值的所有map集合

58. SortedMap<Integer, String> subMap = virtualNodes.tailMap(hash);

59. //找到比该值大的第一个虚拟节点, 如果没有比它大的虚拟节点, 根据哈希环, 则返回第一个节点.

60. Integer targetKey = subMap.size() == 0 ? virtualNodes.firstKey() : subMap.firstKey();

61. //通过该虚拟节点获得真实节点的名称

62. String virtualNodeName = virtualNodes.get(targetKey);

63. String realNodeName = virtualNodeName.split("@")[0];

64. return realNodeName;

65. }

66. public static int getN(){

67. return (int)(Math.random() * 128);

68. }

69. public static int FVNHash(String data){

70. final int p = 16777619;

71. int hash = (int)2166136261L;

72. for(int i = 0; i < data.length(); i++)

73. hash = (hash ^ data.charAt(i)) * p;

74. hash += hash << 13;

75. hash ^= hash >> 7;

76. hash += hash << 3;

77. hash ^= hash >> 17;

78. hash += hash << 5;

79. return hash < 0 ? Math.abs(hash) : hash;

80. }

81. }

82. /* 运行结果片段

83. 55.1.13.47:6240 的请求将由 192.168.0.1 处理

84. 5.49.56.126:1105 的请求将由 192.168.0.1 处理

85. 90.41.8.88:6884 的请求将由 192.168.0.2 处理

86. 26.107.104.81:2989 的请求将由 192.168.0.2 处理

87. 114.66.6.56:8233 的请求将由 192.168.0.1 处理

88. 123.74.52.94:5523 的请求将由 192.168.0.1 处理

89. 104.59.60.2:7502 的请求将由 192.168.0.2 处理

90. 4.94.30.79:1299 的请求将由 192.168.0.1 处理

91. 10.44.37.73:9332 的请求将由 192.168.0.2 处理

92. 115.93.93.82:6333 的请求将由 192.168.0.2 处理

93. 15.24.97.66:9177 的请求将由 192.168.0.2 处理

94. 100.39.98.10:1023 的请求将由 192.168.0.2 处理

95. 61.118.87.26:5108 的请求将由 192.168.0.2 处理

96. 17.79.104.35:3901 的请求将由 192.168.0.1 处理

97. 95.36.5.25:8020 的请求将由 192.168.0.2 处理

98. 126.74.56.71:7792 的请求将由 192.168.0.2 处理

99. 14.63.56.45:8275 的请求将由 192.168.0.1 处理

100. 58.53.44.71:2089 的请求将由 192.168.0.3 处理

101. 80.64.57.43:6144 的请求将由 192.168.0.2 处理

102. 46.65.4.18:7649 的请求将由 192.168.0.2 处理

103. 57.35.27.62:9607 的请求将由 192.168.0.2 处理

104. 81.114.72.3:3444 的请求将由 192.168.0.1 处理

105. 38.18.61.26:6295 的请求将由 192.168.0.2 处理

106. 71.75.18.82:9686 的请求将由 192.168.0.2 处理

107. 26.11.98.111:3781 的请求将由 192.168.0.1 处理

108. 62.86.23.37:8570 的请求将由 192.168.0.3 处理

109. */

经过上面的测试我们可以看到性能较好的服务器1和服务器2分担了大部分的请求，只有少部分请求落到了性能较差的服务器3上，已经初步实现了负载均衡。

下面我们将结合zookeeper，搭建一个更加逼真的服务器集群，看看在部分服务器上线下线的过程中，一致性哈希算法是否仍能够实现负载均衡。

三. 结合zookeeper搭建环境

环境介绍

首先会通过启动多台虚拟机模拟服务器集群，各台服务器都提供一个相同的接口供消费者消费。

同时会有一个消费者线程不断地向服务器集群发起请求，这些请求会经过一致性哈希算法均衡负载到各个服务器。

为了能够模拟上述场景, 我们必须在客户端维护一个服务器列表, 使得客户端能够通过一致性哈希算法选择服务器发送。(现实中可能会把一致性哈希算法实现在前端服务器, 客户先访问前端服务器, 再路由到后端服务器集群)。

但是我们的重点是模拟服务器的宕机和上线，看看一致性哈希算法是否仍能实现负载均衡。所以客户端必须能够感知服务器端的变化并动态地调整它的服务器列表。

为了完成这项工作, 我们引入 zookeeper, zookeeper的数据一致性算法保证数据实时, 准确, 客户端能够通过 zookeeper得知实时的服务器情况。

具体操作是这样的: 服务器集群先以临时节点的方式连接到 zookeeper, 并在 zookeeper上注册自己的接口服务(注册节点). 客户端连接上 zookeeper后, 把已注册的节点(服务器)添加到自己的服务器列表中。

如果有服务器宕机的话, 由于当初注册的是瞬时节点的原因, 该台服务器节点会从 zookeeper中注销。客户端监听到服务器节点有变时, 也会动态调整自己的服务器列表, 把当宕机的服务器从服务器列表中删除, 因此不会再向该服务器发送请求, 负载均衡的任务将交到剩余的机器身上。

当有服务器从新连接上集群后, 客户端的服务器列表也会更新, 哈希环也将做出相应的变化以提供负载均衡。

具体操作:

I. 搭建 zookeeper集群环境:

1. 创建3个 zookeeper服务, 构成集群. 在各自的 data文件夹中添加一个 myid文件, 各个id分别为 1,2,3.

2. 重新复制一份配置文件, 在配置文件中配置各个 zookeeper的端口号. 本案例中三台 zookeeper分别在 2181,2182,2183端口

1. 启动 zookeeper集群

由于zookeeper不是本案例的重点, 细节暂不展开讲了.

II. 创建服务器集群, 提供RPC远程调用服务

1. 首先创建一个服务器项目(使用Maven), 添加 zookeeper依赖

2. 创建常量接口, 用于存储连接 zookeeper 的信息

1. public interface Constant {

2. //zookeeper集群的地址

3. String ZK_HOST = "192.168.117.129:2181,192.168.117.129:2182,192.168.117.129:2183";

4. //连接zookeeper的超时时间

5. int ZK_TIME_OUT = 5000;

6. //服务器所发布的远程服务在zookeeper中的注册地址, 也就是说这个节点中保存了各个服务器提供的接口

7. String ZK_REGISTRY = "/provider";

8. //zookeeper集群中注册服务的url地址的瞬时节点

9. String ZK_RMI = ZK_REGISTRY + "/rmi";

10. }

3.封装操作 zookeeper和发布远程服务的接口供自己调用, 本案例中发布远程服务使用Java自身提供的 rmi包完成, 如果没有了解过可以参考这篇

1. public class ServiceProvider {

2. private CountDownLatch latch = new CountDownLatch(1);

3. /**

4. * 连接zookeeper集群

5. */

6. public ZooKeeper connectToZK(){

7. ZooKeeper zk = null;

8. try {

9. zk = new ZooKeeper(Constant.ZK_HOST, Constant.ZK_TIME_OUT, new Watcher() {

10. @Override

11. public void process(WatchedEvent watchedEvent) {

12. //如果连接上了就唤醒当前线程.

13. latch.countDown();

14. }

15. });

16. latch.await();//还没连接上时当前线程等待

17. } catch (Exception e) {

18. e.printStackTrace();

19. }

20. return zk;

21. }

22. /**

23. * 创建znode节点

24. * @param zk

25. * @param url 节点中写入的数据

26. */

27. public void createNode(ZooKeeper zk, String url){

28. try{

29. //要把写入的数据转化为字节数组

30. byte[] data = url.getBytes();

31. zk.create(Constant.ZK_RMI, data, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);

32. } catch (Exception e) {

33. e.printStackTrace();

34. }

35. }

36. /**

37. * 发布rmi服务

38. */

39. public String publishService(Remote remote, String host, int port){

40. String url = null;

41. try{

42. LocateRegistry.createRegistry(port);

43. url = "rmi://" + host + ":" + port + "/rmiService";

44. Naming.bind(url, remote);

45. } catch (Exception e) {

46. e.printStackTrace();

47. }

48. return url;

49. }

50. /**

51. * 发布rmi服务, 并且将服务的url注册到zookeeper集群中

52. */

53. public void publish(Remote remote, String host, int port){

54. //调用publishService, 得到服务的url地址

55. String url = publishService(remote, host, port);

56. if(null != url){

57. ZooKeeper zk = connectToZK();//连接到zookeeper

58. if(null != zk){

59. createNode(zk, url);

60. }

61. }

62. }

63. }

1. 自定义远程服务. 服务提供一个简单的方法: 客户端发来一个字符串, 服务器在字符串前面添加上 Hello, 并返回字符串。

1. //UserService

2. public interface UserService extends Remote {

3. public String helloRmi(String name) throws RemoteException;

4. }

5. //UserServiceImpl

6. public class UserServiceImpl implements UserService {

7. public UserServiceImpl() throws RemoteException{

8. super();

9. }

10. @Override

11. public String helloRmi(String name) throws RemoteException {

12. return "Hello " + name + "!";

13. }

14. }

1. 修改端口号, 启动多个java虚拟机, 模拟服务器集群. 为了方便演示, 自定义7777, 8888, 9999端口开启3个服务器进程, 到时会模拟7777端口的服务器宕机和修复重连。

1. public static void main(String[] args) throws RemoteException {

2. //创建工具类对象

3. ServiceProvider sp = new ServiceProvider();

4. //创建远程服务对象

5. UserService userService = new UserServiceImpl();

6. //完成发布

7. sp.publish(userService, "localhost", 9999);

8. }

III. 编写客户端程序(运用一致性哈希算法实现负载均衡

1. 封装客户端接口：

1. public class ServiceConsumer {

2. /**

3. * 提供远程服务的服务器列表, 只记录远程服务的url

4. */

5. private volatile List<String> urls = new LinkedList<>();

6. /**

7. * 远程服务对应的虚拟节点集合

8. */

9. private static TreeMap<Integer, String> virtualNodes = new TreeMap<>();

10. public ServiceConsumer(){

11. ZooKeeper zk = connectToZK();//客户端连接到zookeeper

12. if(null != zk){

13. //连接上后关注zookeeper中的节点变化(服务器变化)

14. watchNode(zk);

15. }

16. }

17. private void watchNode(final ZooKeeper zk) {

18. try{

19. //观察/provider节点下的子节点是否有变化(是否有服务器登入或登出)

20. List<String> nodeList = zk.getChildren(Constants.ZK_REGISTRY, new Watcher() {

21. @Override

22. public void process(WatchedEvent watchedEvent) {

23. //如果服务器节点有变化就重新获取

24. if(watchedEvent.getType() == Event.EventType.NodeChildrenChanged){

25. System.out.println("服务器端有变化, 可能有旧服务器宕机或者新服务器加入集群...");

26. watchNode(zk);

27. }

28. }

29. });

30. //将获取到的服务器节点数据保存到集合中, 也就是获得了远程服务的访问url地址

31. List<String> dataList = new LinkedList<>();

32. TreeMap<Integer, String> newVirtualNodesList = new TreeMap<>();

33. for(String nodeStr : nodeList){

34. byte[] data = zk.getData(Constants.ZK_REGISTRY + "/" + nodeStr, false, null);

35. //放入服务器列表的url

36. String url = new String(data);

37. //为每个服务器分配虚拟节点, 为了方便模拟, 默认开启在9999端口的服务器性能较差, 只分配300个虚拟节点, 其他分配1000个.

38. if(url.contains("9999")){

39. for(int i = 1; i <= 300; i++){

40. newVirtualNodesList.put(FVNHash(url + "@" + i), url + "@" + i);

41. }

42. }else{

43. for(int i = 1; i <= 1000; i++){

44. newVirtualNodesList.put(FVNHash(url + "@" + i), url + "@" + i);

45. }

46. }

47. dataList.add(url);

48. }

49. urls = dataList;

50. virtualNodes = newVirtualNodesList;

51. dataList = null;//好让垃圾回收器尽快收集

52. newVirtualNodesList = null;

53. } catch (Exception e) {

54. e.printStackTrace();

55. }

56. }

57. /**

58. * 根据url获得远程服务对象

59. */

60. public <T> T lookUpService(String url){

61. T remote = null;

62. try{

63. remote = (T)Naming.lookup(url);

64. } catch (Exception e) {

65. //如果该url连接不上, 很有可能是该服务器挂了, 这时使用服务器列表中的第一个服务器url重新获取远程对象.

66. if(e instanceof ConnectException){

67. if (urls.size() != 0){

68. url = urls.get(0);

69. return lookUpService(url);

70. }

71. }

72. }

73. return remote;

74. }

75. /**

76. * 通过一致性哈希算法, 选取一个url, 最后返回一个远程服务对象

77. */

78. public <T extends Remote> T lookUp(){

79. T service = null;

80. //随机计算一个哈希值

81. int hash = FVNHash(Math.random() * 10000 + "");

82. //得到大于该哈希值的所有map集合

83. SortedMap<Integer, String> subMap = virtualNodes.tailMap(hash);

84. //找到比该值大的第一个虚拟节点, 如果没有比它大的虚拟节点, 根据哈希环, 则返回第一个节点.

85. Integer targetKey = subMap.size() == 0 ? virtualNodes.firstKey() : subMap.firstKey();

86. //通过该虚拟节点获得服务器url

87. String virtualNodeName = virtualNodes.get(targetKey);

88. String url = virtualNodeName.split("@")[0];

89. //根据服务器url获取远程服务对象

90. service = lookUpService(url);

91. System.out.print("提供本次服务的地址为: " + url + ", 返回结果: ");

92. return service;

93. }

94. private CountDownLatch latch = new CountDownLatch(1);

95. public ZooKeeper connectToZK(){

96. ZooKeeper zk = null;

97. try {

98. zk = new ZooKeeper(Constants.ZK_HOST, Constants.ZK_TIME_OUT, new Watcher() {

99. @Override

100. public void process(WatchedEvent watchedEvent) {

101. //判断是否连接zk集群

102. latch.countDown();//唤醒处于等待状态的当前线程

103. }

104. });

105. latch.await();//没有连接上的时候当前线程处于等待状态.

106. } catch (IOException e) {

107. e.printStackTrace();

108. } catch (InterruptedException e) {

109. e.printStackTrace();

110. }

111. return zk;

112. }

113. public static int FVNHash(String data){

114. final int p = 16777619;

115. int hash = (int)2166136261L;

116. for(int i = 0; i < data.length(); i++)

117. hash = (hash ^ data.charAt(i)) * p;

118. hash += hash << 13;

119. hash ^= hash >> 7;

120. hash += hash << 3;

121. hash ^= hash >> 17;

122. hash += hash << 5;

123. return hash < 0 ? Math.abs(hash) : hash;

124. }

125. }

1. 启动客户端进行测试：

1. public static void main(String[] args){

2. ServiceConsumer sc = new ServiceConsumer();//创建工具类对象

3. while(true){

4. //获得rmi远程服务对象

5. UserService userService = sc.lookUp();

6. try{

7. //调用远程方法

8. String result = userService.helloRmi("炭烧生蚝");

9. System.out.println(result);

10. Thread.sleep(100);

11. }catch(Exception e){

12. e.printStackTrace();

13. }

14. }

15. }

1. 客户端跑起来后, 在显示台不断进行打印...下面将对数据进行统计。

IV. 对服务器调用数据进行统计分析

重温一遍模拟的过程: 首先分别在7777, 8888, 9999端口启动了3台服务器. 然后启动客户端进行访问. 7777, 8888端口的两台服务器设置性能指数为1000, 而9999端口的服务器性能指数设置为300。

在客户端运行期间, 我手动关闭了8888端口的服务器, 客户端正常打印出服务器变化信息。此时理论上不会有访问被路由到8888端口的服务器。当我重新启动8888端口服务器时, 客户端打印出服务器变化信息, 访问能正常到达8888端口服务器。

下面对各服务器的访问量进行统计, 看是否实现了负载均衡。

测试程序如下:

1. public class DataStatistics {

2. private static float ReqToPort7777 = 0;

3. private static float ReqToPort8888 = 0;

4. private static float ReqToPort9999 = 0;

5. public static void main(String[] args) {

6. BufferedReader br = null;

7. try {

8. br = new BufferedReader(new FileReader("C://test.txt"));

9. String line = null;

10. while(null != (line = br.readLine())){

11. if(line.contains("7777")){

12. ReqToPort7777++;

13. }else if(line.contains("8888")){

14. ReqToPort8888++;

15. }else if(line.contains("9999")){

16. ReqToPort9999++;

17. }else{

18. print(false);

19. }

20. }

21. print(true);

22. } catch (Exception e) {

23. e.printStackTrace();

24. }finally {

25. if(null != br){

26. try {

27. br.close();

28. } catch (IOException e) {

29. e.printStackTrace();

30. }

31. br = null;

32. }

33. }

34. }

35. private static void print(boolean isEnd){

36. if(!isEnd){

37. System.out.println("------------- 服务器集群发生变化 -------------");

38. }else{

39. System.out.println("------------- 最后一次统计 -------------");

40. }

41. System.out.println("截取自上次服务器变化到现在: ");

42. float total = ReqToPort7777 + ReqToPort8888 + ReqToPort9999;

43. System.out.println("7777端口服务器访问量为: " + ReqToPort7777 + ", 占比" + (ReqToPort7777 / total));

44. System.out.println("8888端口服务器访问量为: " + ReqToPort8888 + ", 占比" + (ReqToPort8888 / total));

45. System.out.println("9999端口服务器访问量为: " + ReqToPort9999 + ", 占比" + (ReqToPort9999 / total));

46. ReqToPort7777 = 0;

47. ReqToPort8888 = 0;

48. ReqToPort9999 = 0;

49. }

50. }

51. /* 以下是输出结果

52. ------------- 服务器集群发生变化 -------------

53. 截取自上次服务器变化到现在:

54. 7777端口服务器访问量为: 198.0, 占比0.4419643

55. 8888端口服务器访问量为: 184.0, 占比0.4107143

56. 9999端口服务器访问量为: 66.0, 占比0.14732143

57. ------------- 服务器集群发生变化 -------------

58. 截取自上次服务器变化到现在:

59. 7777端口服务器访问量为: 510.0, 占比0.7589286

60. 8888端口服务器访问量为: 1.0, 占比0.0014880953

61. 9999端口服务器访问量为: 161.0, 占比0.23958333

62. ------------- 最后一次统计 -------------

63. 截取自上次服务器变化到现在:

64. 7777端口服务器访问量为: 410.0, 占比0.43248945

65. 8888端口服务器访问量为: 398.0, 占比0.41983122

66. 9999端口服务器访问量为: 140.0, 占比0.14767933

67. */

V. 结果

从测试数据可以看出, 不管是8888端口服务器宕机之前, 还是宕机之后, 三台服务器接收的访问量和性能指数成正比，成功地验证了一致性哈希算法的负载均衡作用。

四. 扩展思考

初识一致性哈希算法的时候, 对这种奇特的思路佩服得五体投地。但是一致性哈希算法除了能够让后端服务器实现负载均衡, 还有一个特点可能是其他负载均衡算法所不具备的。

这个特点是基于哈希函数的, 我们知道通过哈希函数, 固定的输入能够产生固定的输出. 换句话说, 同样的请求会路由到相同的服务器. 这点就很牛逼了, 我们可以结合一致性哈希算法和缓存机制提供后端服务器的性能。

比如说在一个分布式系统中, 有一个服务器集群提供查询用户信息的方法, 每个请求将会带着用户的 uid到达, 我们可以通过哈希函数进行处理(从上面的演示代码可以看到, 这点是可以轻松实现的), 使同样的 uid路由到某个独定的服务器. 这样我们就可以在服务器上对该的 uid背后的用户信息进行缓存, 从而减少对数据库或其他中间件的操作, 从而提高系统效率。

当然如果使用该策略的话, 你可能还要考虑缓存更新等操作, 但作为一种优良的策略, 我们可以考虑在适当的场合灵活运用。

以上思考受启发于 Dubbo框架中对其实现的四种负载均衡策略的描述。

精彩回顾：

强烈推荐：

《Java 极客技术》知识星球限时优惠，现在加入只需 50 元，仅限前 1000 名，机不可失时不再来。长按识别下面的二维码即可加入，趁早行动吧！

隆重介绍：

Java 极客技术公众号，是由一群热爱 Java 开发的技术人组建成立，专注分享原创、高质量的 Java 文章。如果您觉得我们的文章还不错，请帮忙赞赏、在看、转发支持，鼓励我们分享出更好的文章。